home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / devtools / flex-2.5.4.tar.gz / flex-2.5.4.tar / flex-2.5.4 / skel.c < prev    next >
C/C++ Source or Header  |  1996-09-10  |  42KB  |  1,549 lines

  1. /* File created from flex.skl via mkskel.sh */
  2.  
  3. #include "flexdef.h"
  4.  
  5. const char *skel[] = {
  6.   "/* A lexical scanner generated by flex */",
  7.   "",
  8.   "/* Scanner skeleton version:",
  9.   " * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $",
  10.   " */",
  11.   "",
  12.   "#define FLEX_SCANNER",
  13.   "#define YY_FLEX_MAJOR_VERSION 2",
  14.   "#define YY_FLEX_MINOR_VERSION 5",
  15.   "",
  16.   "%-",
  17.   "#include <stdio.h>",
  18.   "%*",
  19.   "",
  20.   "",
  21.   "/* cfront 1.2 defines \"c_plusplus\" instead of \"__cplusplus\" */",
  22.   "#ifdef c_plusplus",
  23.   "#ifndef __cplusplus",
  24.   "#define __cplusplus",
  25.   "#endif",
  26.   "#endif",
  27.   "",
  28.   "",
  29.   "#ifdef __cplusplus",
  30.   "",
  31.   "#include <stdlib.h>",
  32.   "%+",
  33.   "class istream;",
  34.   "%*",
  35.   "#include <unistd.h>",
  36.   "",
  37.   "/* Use prototypes in function declarations. */",
  38.   "#define YY_USE_PROTOS",
  39.   "",
  40.   "/* The \"const\" storage-class-modifier is valid. */",
  41.   "#define YY_USE_CONST",
  42.   "",
  43.   "#else    /* ! __cplusplus */",
  44.   "",
  45.   "#if __STDC__",
  46.   "",
  47.   "#define YY_USE_PROTOS",
  48.   "#define YY_USE_CONST",
  49.   "",
  50.   "#endif    /* __STDC__ */",
  51.   "#endif    /* ! __cplusplus */",
  52.   "",
  53.   "#ifdef __TURBOC__",
  54.   " #pragma warn -rch",
  55.   " #pragma warn -use",
  56.   "#include <io.h>",
  57.   "#include <stdlib.h>",
  58.   "#define YY_USE_CONST",
  59.   "#define YY_USE_PROTOS",
  60.   "#endif",
  61.   "",
  62.   "#ifdef YY_USE_CONST",
  63.   "#define yyconst const",
  64.   "#else",
  65.   "#define yyconst",
  66.   "#endif",
  67.   "",
  68.   "",
  69.   "#ifdef YY_USE_PROTOS",
  70.   "#define YY_PROTO(proto) proto",
  71.   "#else",
  72.   "#define YY_PROTO(proto) ()",
  73.   "#endif",
  74.   "",
  75.   "/* Returned upon end-of-file. */",
  76.   "#define YY_NULL 0",
  77.   "",
  78.   "/* Promotes a possibly negative, possibly signed char to an unsigned",
  79.   " * integer for use as an array index.  If the signed char is negative,",
  80.   " * we want to instead treat it as an 8-bit unsigned char, hence the",
  81.   " * double cast.",
  82.   " */",
  83.   "#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)",
  84.   "",
  85.   "/* Enter a start condition.  This macro really ought to take a parameter,",
  86.   " * but we do it the disgusting crufty way forced on us by the ()-less",
  87.   " * definition of BEGIN.",
  88.   " */",
  89.   "#define BEGIN yy_start = 1 + 2 *",
  90.   "",
  91.   "/* Translate the current start state into a value that can be later handed",
  92.   " * to BEGIN to return to the state.  The YYSTATE alias is for lex",
  93.   " * compatibility.",
  94.   " */",
  95.   "#define YY_START ((yy_start - 1) / 2)",
  96.   "#define YYSTATE YY_START",
  97.   "",
  98.   "/* Action number for EOF rule of a given start state. */",
  99.   "#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)",
  100.   "",
  101.   "/* Special action meaning \"start processing a new file\". */",
  102.   "#define YY_NEW_FILE yyrestart( yyin )",
  103.   "",
  104.   "#define YY_END_OF_BUFFER_CHAR 0",
  105.   "",
  106.   "/* Size of default input buffer. */",
  107.   "#define YY_BUF_SIZE 16384",
  108.   "",
  109.   "typedef struct yy_buffer_state *YY_BUFFER_STATE;",
  110.   "",
  111.   "extern int yyleng;",
  112.   "%-",
  113.   "extern FILE *yyin, *yyout;",
  114.   "%*",
  115.   "",
  116.   "#define EOB_ACT_CONTINUE_SCAN 0",
  117.   "#define EOB_ACT_END_OF_FILE 1",
  118.   "#define EOB_ACT_LAST_MATCH 2",
  119.   "",
  120.   "/* The funky do-while in the following #define is used to turn the definition",
  121.   " * int a single C statement (which needs a semi-colon terminator).  This",
  122.   " * avoids problems with code like:",
  123.   " *",
  124.   " *     if ( condition_holds )",
  125.   " *        yyless( 5 );",
  126.   " *    else",
  127.   " *        do_something_else();",
  128.   " *",
  129.   " * Prior to using the do-while the compiler would get upset at the",
  130.   " * \"else\" because it interpreted the \"if\" statement as being all",
  131.   " * done when it reached the ';' after the yyless() call.",
  132.   " */",
  133.   "",
  134.   "/* Return all but the first 'n' matched characters back to the input stream. */",
  135.   "",
  136.   "#define yyless(n) \\",
  137.   "    do \\",
  138.   "        { \\",
  139.   "        /* Undo effects of setting up yytext. */ \\",
  140.   "        *yy_cp = yy_hold_char; \\",
  141.   "        YY_RESTORE_YY_MORE_OFFSET \\",
  142.   "        yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \\",
  143.   "        YY_DO_BEFORE_ACTION; /* set up yytext again */ \\",
  144.   "        } \\",
  145.   "    while ( 0 )",
  146.   "",
  147.   "#define unput(c) yyunput( c, yytext_ptr )",
  148.   "",
  149.   "/* The following is because we cannot portably get our hands on size_t",
  150.   " * (without autoconf's help, which isn't available because we want",
  151.   " * flex-generated scanners to compile on their own).",
  152.   " */",
  153.   "typedef unsigned int yy_size_t;",
  154.   "",
  155.   "",
  156.   "struct yy_buffer_state",
  157.   "    {",
  158.   "%-",
  159.   "    FILE *yy_input_file;",
  160.   "%+",
  161.   "    istream* yy_input_file;",
  162.   "%*",
  163.   "",
  164.   "    char *yy_ch_buf;        /* input buffer */",
  165.   "    char *yy_buf_pos;        /* current position in input buffer */",
  166.   "",
  167.   "    /* Size of input buffer in bytes, not including room for EOB",
  168.   "     * characters.",
  169.   "     */",
  170.   "    yy_size_t yy_buf_size;",
  171.   "",
  172.   "    /* Number of characters read into yy_ch_buf, not including EOB",
  173.   "     * characters.",
  174.   "     */",
  175.   "    int yy_n_chars;",
  176.   "",
  177.   "    /* Whether we \"own\" the buffer - i.e., we know we created it,",
  178.   "     * and can realloc() it to grow it, and should free() it to",
  179.   "     * delete it.",
  180.   "     */",
  181.   "    int yy_is_our_buffer;",
  182.   "",
  183.   "    /* Whether this is an \"interactive\" input source; if so, and",
  184.   "     * if we're using stdio for input, then we want to use getc()",
  185.   "     * instead of fread(), to make sure we stop fetching input after",
  186.   "     * each newline.",
  187.   "     */",
  188.   "    int yy_is_interactive;",
  189.   "",
  190.   "    /* Whether we're considered to be at the beginning of a line.",
  191.   "     * If so, '^' rules will be active on the next match, otherwise",
  192.   "     * not.",
  193.   "     */",
  194.   "    int yy_at_bol;",
  195.   "",
  196.   "    /* Whether to try to fill the input buffer when we reach the",
  197.   "     * end of it.",
  198.   "     */",
  199.   "    int yy_fill_buffer;",
  200.   "",
  201.   "    int yy_buffer_status;",
  202.   "#define YY_BUFFER_NEW 0",
  203.   "#define YY_BUFFER_NORMAL 1",
  204.   "    /* When an EOF's been seen but there's still some text to process",
  205.   "     * then we mark the buffer as YY_EOF_PENDING, to indicate that we",
  206.   "     * shouldn't try reading from the input source any more.  We might",
  207.   "     * still have a bunch of tokens to match, though, because of",
  208.   "     * possible backing-up.",
  209.   "     *",
  210.   "     * When we actually see the EOF, we change the status to \"new\"",
  211.   "     * (via yyrestart()), so that the user can continue scanning by",
  212.   "     * just pointing yyin at a new input file.",
  213.   "     */",
  214.   "#define YY_BUFFER_EOF_PENDING 2",
  215.   "    };",
  216.   "",
  217.   "%- Standard (non-C++) definition",
  218.   "static YY_BUFFER_STATE yy_current_buffer = 0;",
  219.   "%*",
  220.   "",
  221.   "/* We provide macros for accessing buffer states in case in the",
  222.   " * future we want to put the buffer states in a more general",
  223.   " * \"scanner state\".",
  224.   " */",
  225.   "#define YY_CURRENT_BUFFER yy_current_buffer",
  226.   "",
  227.   "",
  228.   "%- Standard (non-C++) definition",
  229.   "/* yy_hold_char holds the character lost when yytext is formed. */",
  230.   "static char yy_hold_char;",
  231.   "",
  232.   "static int yy_n_chars;        /* number of characters read into yy_ch_buf */",
  233.   "",
  234.   "",
  235.   "int yyleng;",
  236.   "",
  237.   "/* Points to current character in buffer. */",
  238.   "static char *yy_c_buf_p = (char *) 0;",
  239.   "static int yy_init = 1;        /* whether we need to initialize */",
  240.   "static int yy_start = 0;    /* start state number */",
  241.   "",
  242.   "/* Flag which is used to allow yywrap()'s to do buffer switches",
  243.   " * instead of setting up a fresh yyin.  A bit of a hack ...",
  244.   " */",
  245.   "static int yy_did_buffer_switch_on_eof;",
  246.   "",
  247.   "void yyrestart YY_PROTO(( FILE *input_file ));",
  248.   "",
  249.   "void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));",
  250.   "void yy_load_buffer_state YY_PROTO(( void ));",
  251.   "YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));",
  252.   "void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));",
  253.   "void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));",
  254.   "void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));",
  255.   "#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )",
  256.   "",
  257.   "YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));",
  258.   "YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));",
  259.   "YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));",
  260.   "%*",
  261.   "",
  262.   "static void *yy_flex_alloc YY_PROTO(( yy_size_t ));",
  263.   "static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));",
  264.   "static void yy_flex_free YY_PROTO(( void * ));",
  265.   "",
  266.   "#define yy_new_buffer yy_create_buffer",
  267.   "",
  268.   "#define yy_set_interactive(is_interactive) \\",
  269.   "    { \\",
  270.   "    if ( ! yy_current_buffer ) \\",
  271.   "        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\",
  272.   "    yy_current_buffer->yy_is_interactive = is_interactive; \\",
  273.   "    }",
  274.   "",
  275.   "#define yy_set_bol(at_bol) \\",
  276.   "    { \\",
  277.   "    if ( ! yy_current_buffer ) \\",
  278.   "        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\",
  279.   "    yy_current_buffer->yy_at_bol = at_bol; \\",
  280.   "    }",
  281.   "",
  282.   "#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)",
  283.   "",
  284.   "%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here",
  285.   "",
  286.   "%- Standard (non-C++) definition",
  287.   "static yy_state_type yy_get_previous_state YY_PROTO(( void ));",
  288.   "static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));",
  289.   "static int yy_get_next_buffer YY_PROTO(( void ));",
  290.   "static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));",
  291.   "%*",
  292.   "",
  293.   "/* Done after the current pattern has been matched and before the",
  294.   " * corresponding action - sets up yytext.",
  295.   " */",
  296.   "#define YY_DO_BEFORE_ACTION \\",
  297.   "    yytext_ptr = yy_bp; \\",
  298.   "%% code to fiddle yytext and yyleng for yymore() goes here",
  299.   "    yy_hold_char = *yy_cp; \\",
  300.   "    *yy_cp = '\\0'; \\",
  301.   "%% code to copy yytext_ptr to yytext[] goes here, if %array",
  302.   "    yy_c_buf_p = yy_cp;",
  303.   "",
  304.   "%% data tables for the DFA and the user's section 1 definitions go here",
  305.   "",
  306.   "/* Macros after this point can all be overridden by user definitions in",
  307.   " * section 1.",
  308.   " */",
  309.   "",
  310.   "#ifndef YY_SKIP_YYWRAP",
  311.   "#ifdef __cplusplus",
  312.   "extern \"C\" int yywrap YY_PROTO(( void ));",
  313.   "#else",
  314.   "extern int yywrap YY_PROTO(( void ));",
  315.   "#endif",
  316.   "#endif",
  317.   "",
  318.   "%-",
  319.   "#ifndef YY_NO_UNPUT",
  320.   "static void yyunput YY_PROTO(( int c, char *buf_ptr ));",
  321.   "#endif",
  322.   "%*",
  323.   "",
  324.   "#ifndef yytext_ptr",
  325.   "static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));",
  326.   "#endif",
  327.   "",
  328.   "#ifdef YY_NEED_STRLEN",
  329.   "static int yy_flex_strlen YY_PROTO(( yyconst char * ));",
  330.   "#endif",
  331.   "",
  332.   "#ifndef YY_NO_INPUT",
  333.   "%- Standard (non-C++) definition",
  334.   "#ifdef __cplusplus",
  335.   "static int yyinput YY_PROTO(( void ));",
  336.   "#else",
  337.   "static int input YY_PROTO(( void ));",
  338.   "#endif",
  339.   "%*",
  340.   "#endif",
  341.   "",
  342.   "#if YY_STACK_USED",
  343.   "static int yy_start_stack_ptr = 0;",
  344.   "static int yy_start_stack_depth = 0;",
  345.   "static int *yy_start_stack = 0;",
  346.   "#ifndef YY_NO_PUSH_STATE",
  347.   "static void yy_push_state YY_PROTO(( int new_state ));",
  348.   "#endif",
  349.   "#ifndef YY_NO_POP_STATE",
  350.   "static void yy_pop_state YY_PROTO(( void ));",
  351.   "#endif",
  352.   "#ifndef YY_NO_TOP_STATE",
  353.   "static int yy_top_state YY_PROTO(( void ));",
  354.   "#endif",
  355.   "",
  356.   "#else",
  357.   "#define YY_NO_PUSH_STATE 1",
  358.   "#define YY_NO_POP_STATE 1",
  359.   "#define YY_NO_TOP_STATE 1",
  360.   "#endif",
  361.   "",
  362.   "#ifdef YY_MALLOC_DECL",
  363.   "YY_MALLOC_DECL",
  364.   "#else",
  365.   "#if __STDC__",
  366.   "#ifndef __cplusplus",
  367.   "#include <stdlib.h>",
  368.   "#endif",
  369.   "#else",
  370.   "/* Just try to get by without declaring the routines.  This will fail",
  371.   " * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)",
  372.   " * or sizeof(void*) != sizeof(int).",
  373.   " */",
  374.   "#endif",
  375.   "#endif",
  376.   "",
  377.   "/* Amount of stuff to slurp up with each read. */",
  378.   "#ifndef YY_READ_BUF_SIZE",
  379.   "#define YY_READ_BUF_SIZE 8192",
  380.   "#endif",
  381.   "",
  382.   "/* Copy whatever the last rule matched to the standard output. */",
  383.   "",
  384.   "#ifndef ECHO",
  385.   "%- Standard (non-C++) definition",
  386.   "/* This used to be an fputs(), but since the string might contain NUL's,",
  387.   " * we now use fwrite().",
  388.   " */",
  389.   "#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )",
  390.   "%+ C++ definition",
  391.   "#define ECHO LexerOutput( yytext, yyleng )",
  392.   "%*",
  393.   "#endif",
  394.   "",
  395.   "/* Gets input and stuffs it into \"buf\".  number of characters read, or YY_NULL,",
  396.   " * is returned in \"result\".",
  397.   " */",
  398.   "#ifndef YY_INPUT",
  399.   "#define YY_INPUT(buf,result,max_size) \\",
  400.   "%% fread()/read() definition of YY_INPUT goes here unless we're doing C++",
  401.   "%+ C++ definition",
  402.   "    if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \\",
  403.   "        YY_FATAL_ERROR( \"input in flex scanner failed\" );",
  404.   "%*",
  405.   "#endif",
  406.   "",
  407.   "/* No semi-colon after return; correct usage is to write \"yyterminate();\" -",
  408.   " * we don't want an extra ';' after the \"return\" because that will cause",
  409.   " * some compilers to complain about unreachable statements.",
  410.   " */",
  411.   "#ifndef yyterminate",
  412.   "#define yyterminate() return YY_NULL",
  413.   "#endif",
  414.   "",
  415.   "/* Number of entries by which start-condition stack grows. */",
  416.   "#ifndef YY_START_STACK_INCR",
  417.   "#define YY_START_STACK_INCR 25",
  418.   "#endif",
  419.   "",
  420.   "/* Report a fatal error. */",
  421.   "#ifndef YY_FATAL_ERROR",
  422.   "%-",
  423.   "#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )",
  424.   "%+",
  425.   "#define YY_FATAL_ERROR(msg) LexerError( msg )",
  426.   "%*",
  427.   "#endif",
  428.   "",
  429.   "/* Default declaration of generated scanner - a define so the user can",
  430.   " * easily add parameters.",
  431.   " */",
  432.   "#ifndef YY_DECL",
  433.   "%- Standard (non-C++) definition",
  434.   "#define YY_DECL int yylex YY_PROTO(( void ))",
  435.   "%+ C++ definition",
  436.   "#define YY_DECL int yyFlexLexer::yylex()",
  437.   "%*",
  438.   "#endif",
  439.   "",
  440.   "/* Code executed at the beginning of each rule, after yytext and yyleng",
  441.   " * have been set up.",
  442.   " */",
  443.   "#ifndef YY_USER_ACTION",
  444.   "#define YY_USER_ACTION",
  445.   "#endif",
  446.   "",
  447.   "/* Code executed at the end of each rule. */",
  448.   "#ifndef YY_BREAK",
  449.   "#define YY_BREAK break;",
  450.   "#endif",
  451.   "",
  452.   "%% YY_RULE_SETUP definition goes here",
  453.   "",
  454.   "YY_DECL",
  455.   "    {",
  456.   "    register yy_state_type yy_current_state;",
  457.   "    register char *yy_cp, *yy_bp;",
  458.   "    register int yy_act;",
  459.   "",
  460.   "%% user's declarations go here",
  461.   "",
  462.   "    if ( yy_init )",
  463.   "        {",
  464.   "        yy_init = 0;",
  465.   "",
  466.   "#ifdef YY_USER_INIT",
  467.   "        YY_USER_INIT;",
  468.   "#endif",
  469.   "",
  470.   "        if ( ! yy_start )",
  471.   "            yy_start = 1;    /* first start state */",
  472.   "",
  473.   "        if ( ! yyin )",
  474.   "%-",
  475.   "            yyin = stdin;",
  476.   "%+",
  477.   "            yyin = &cin;",
  478.   "%*",
  479.   "",
  480.   "        if ( ! yyout )",
  481.   "%-",
  482.   "            yyout = stdout;",
  483.   "%+",
  484.   "            yyout = &cout;",
  485.   "%*",
  486.   "",
  487.   "        if ( ! yy_current_buffer )",
  488.   "            yy_current_buffer =",
  489.   "                yy_create_buffer( yyin, YY_BUF_SIZE );",
  490.   "",
  491.   "        yy_load_buffer_state();",
  492.   "        }",
  493.   "",
  494.   "    while ( 1 )        /* loops until end-of-file is reached */",
  495.   "        {",
  496.   "%% yymore()-related code goes here",
  497.   "        yy_cp = yy_c_buf_p;",
  498.   "",
  499.   "        /* Support of yytext. */",
  500.   "        *yy_cp = yy_hold_char;",
  501.   "",
  502.   "        /* yy_bp points to the position in yy_ch_buf of the start of",
  503.   "         * the current run.",
  504.   "         */",
  505.   "        yy_bp = yy_cp;",
  506.   "",
  507.   "%% code to set up and find next match goes here",
  508.   "",
  509.   "yy_find_action:",
  510.   "%% code to find the action number goes here",
  511.   "",
  512.   "        YY_DO_BEFORE_ACTION;",
  513.   "",
  514.   "%% code for yylineno update goes here",
  515.   "",
  516.   "do_action:    /* This label is used only to access EOF actions. */",
  517.   "",
  518.   "%% debug code goes here",
  519.   "",
  520.   "        switch ( yy_act )",
  521.   "    { /* beginning of action switch */",
  522.   "%% actions go here",
  523.   "",
  524.   "    case YY_END_OF_BUFFER:",
  525.   "        {",
  526.   "        /* Amount of text matched not including the EOB char. */",
  527.   "        int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;",
  528.   "",
  529.   "        /* Undo the effects of YY_DO_BEFORE_ACTION. */",
  530.   "        *yy_cp = yy_hold_char;",
  531.   "        YY_RESTORE_YY_MORE_OFFSET",
  532.   "",
  533.   "        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )",
  534.   "            {",
  535.   "            /* We're scanning a new file or input source.  It's",
  536.   "             * possible that this happened because the user",
  537.   "             * just pointed yyin at a new source and called",
  538.   "             * yylex().  If so, then we have to assure",
  539.   "             * consistency between yy_current_buffer and our",
  540.   "             * globals.  Here is the right place to do so, because",
  541.   "             * this is the first action (other than possibly a",
  542.   "             * back-up) that will match for the new input source.",
  543.   "             */",
  544.   "            yy_n_chars = yy_current_buffer->yy_n_chars;",
  545.   "            yy_current_buffer->yy_input_file = yyin;",
  546.   "            yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;",
  547.   "            }",
  548.   "",
  549.   "        /* Note that here we test for yy_c_buf_p \"<=\" to the position",
  550.   "         * of the first EOB in the buffer, since yy_c_buf_p will",
  551.   "         * already have been incremented past the NUL character",
  552.   "         * (since all states make transitions on EOB to the",
  553.   "         * end-of-buffer state).  Contrast this with the test",
  554.   "         * in input().",
  555.   "         */",
  556.   "        if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )",
  557.   "            { /* This was really a NUL. */",
  558.   "            yy_state_type yy_next_state;",
  559.   "",
  560.   "            yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;",
  561.   "",
  562.   "            yy_current_state = yy_get_previous_state();",
  563.   "",
  564.   "            /* Okay, we're now positioned to make the NUL",
  565.   "             * transition.  We couldn't have",
  566.   "             * yy_get_previous_state() go ahead and do it",
  567.   "             * for us because it doesn't know how to deal",
  568.   "             * with the possibility of jamming (and we don't",
  569.   "             * want to build jamming into it because then it",
  570.   "             * will run more slowly).",
  571.   "             */",
  572.   "",
  573.   "            yy_next_state = yy_try_NUL_trans( yy_current_state );",
  574.   "",
  575.   "            yy_bp = yytext_ptr + YY_MORE_ADJ;",
  576.   "",
  577.   "            if ( yy_next_state )",
  578.   "                {",
  579.   "                /* Consume the NUL. */",
  580.   "                yy_cp = ++yy_c_buf_p;",
  581.   "                yy_current_state = yy_next_state;",
  582.   "                goto yy_match;",
  583.   "                }",
  584.   "",
  585.   "            else",
  586.   "                {",
  587.   "%% code to do back-up for compressed tables and set up yy_cp goes here",
  588.   "                goto yy_find_action;",
  589.   "                }",
  590.   "            }",
  591.   "",
  592.   "        else switch ( yy_get_next_buffer() )",
  593.   "            {",
  594.   "            case EOB_ACT_END_OF_FILE:",
  595.   "                {",
  596.   "                yy_did_buffer_switch_on_eof = 0;",
  597.   "",
  598.   "                if ( yywrap() )",
  599.   "                    {",
  600.   "                    /* Note: because we've taken care in",
  601.   "                     * yy_get_next_buffer() to have set up",
  602.   "                     * yytext, we can now set up",
  603.   "                     * yy_c_buf_p so that if some total",
  604.   "                     * hoser (like flex itself) wants to",
  605.   "                     * call the scanner after we return the",
  606.   "                     * YY_NULL, it'll still work - another",
  607.   "                     * YY_NULL will get returned.",
  608.   "                     */",
  609.   "                    yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;",
  610.   "",
  611.   "                    yy_act = YY_STATE_EOF(YY_START);",
  612.   "                    goto do_action;",
  613.   "                    }",
  614.   "",
  615.   "                else",
  616.   "                    {",
  617.   "                    if ( ! yy_did_buffer_switch_on_eof )",
  618.   "                        YY_NEW_FILE;",
  619.   "                    }",
  620.   "                break;",
  621.   "                }",
  622.   "",
  623.   "            case EOB_ACT_CONTINUE_SCAN:",
  624.   "                yy_c_buf_p =",
  625.   "                    yytext_ptr + yy_amount_of_matched_text;",
  626.   "",
  627.   "                yy_current_state = yy_get_previous_state();",
  628.   "",
  629.   "                yy_cp = yy_c_buf_p;",
  630.   "                yy_bp = yytext_ptr + YY_MORE_ADJ;",
  631.   "                goto yy_match;",
  632.   "",
  633.   "            case EOB_ACT_LAST_MATCH:",
  634.   "                yy_c_buf_p =",
  635.   "                &yy_current_buffer->yy_ch_buf[yy_n_chars];",
  636.   "",
  637.   "                yy_current_state = yy_get_previous_state();",
  638.   "",
  639.   "                yy_cp = yy_c_buf_p;",
  640.   "                yy_bp = yytext_ptr + YY_MORE_ADJ;",
  641.   "                goto yy_find_action;",
  642.   "            }",
  643.   "        break;",
  644.   "        }",
  645.   "",
  646.   "    default:",
  647.   "        YY_FATAL_ERROR(",
  648.   "            \"fatal flex scanner internal error--no action found\" );",
  649.   "    } /* end of action switch */",
  650.   "        } /* end of scanning one token */",
  651.   "    } /* end of yylex */",
  652.   "",
  653.   "%+",
  654.   "yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )",
  655.   "    {",
  656.   "    yyin = arg_yyin;",
  657.   "    yyout = arg_yyout;",
  658.   "    yy_c_buf_p = 0;",
  659.   "    yy_init = 1;",
  660.   "    yy_start = 0;",
  661.   "    yy_flex_debug = 0;",
  662.   "    yylineno = 1;    // this will only get updated if %option yylineno",
  663.   "",
  664.   "    yy_did_buffer_switch_on_eof = 0;",
  665.   "",
  666.   "    yy_looking_for_trail_begin = 0;",
  667.   "    yy_more_flag = 0;",
  668.   "    yy_more_len = 0;",
  669.   "    yy_more_offset = yy_prev_more_offset = 0;",
  670.   "",
  671.   "    yy_start_stack_ptr = yy_start_stack_depth = 0;",
  672.   "    yy_start_stack = 0;",
  673.   "",
  674.   "    yy_current_buffer = 0;",
  675.   "",
  676.   "#ifdef YY_USES_REJECT",
  677.   "    yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];",
  678.   "#else",
  679.   "    yy_state_buf = 0;",
  680.   "#endif",
  681.   "    }",
  682.   "",
  683.   "yyFlexLexer::~yyFlexLexer()",
  684.   "    {",
  685.   "    delete yy_state_buf;",
  686.   "    yy_delete_buffer( yy_current_buffer );",
  687.   "    }",
  688.   "",
  689.   "void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )",
  690.   "    {",
  691.   "    if ( new_in )",
  692.   "        {",
  693.   "        yy_delete_buffer( yy_current_buffer );",
  694.   "        yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );",
  695.   "        }",
  696.   "",
  697.   "    if ( new_out )",
  698.   "        yyout = new_out;",
  699.   "    }",
  700.   "",
  701.   "#ifdef YY_INTERACTIVE",
  702.   "int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )",
  703.   "#else",
  704.   "int yyFlexLexer::LexerInput( char* buf, int max_size )",
  705.   "#endif",
  706.   "    {",
  707.   "    if ( yyin->eof() || yyin->fail() )",
  708.   "        return 0;",
  709.   "",
  710.   "#ifdef YY_INTERACTIVE",
  711.   "    yyin->get( buf[0] );",
  712.   "",
  713.   "    if ( yyin->eof() )",
  714.   "        return 0;",
  715.   "",
  716.   "    if ( yyin->bad() )",
  717.   "        return -1;",
  718.   "",
  719.   "    return 1;",
  720.   "",
  721.   "#else",
  722.   "    (void) yyin->read( buf, max_size );",
  723.   "",
  724.   "    if ( yyin->bad() )",
  725.   "        return -1;",
  726.   "    else",
  727.   "        return yyin->gcount();",
  728.   "#endif",
  729.   "    }",
  730.   "",
  731.   "void yyFlexLexer::LexerOutput( const char* buf, int size )",
  732.   "    {",
  733.   "    (void) yyout->write( buf, size );",
  734.   "    }",
  735.   "%*",
  736.   "",
  737.   "/* yy_get_next_buffer - try to read in a new buffer",
  738.   " *",
  739.   " * Returns a code representing an action:",
  740.   " *    EOB_ACT_LAST_MATCH -",
  741.   " *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position",
  742.   " *    EOB_ACT_END_OF_FILE - end of file",
  743.   " */",
  744.   "",
  745.   "%-",
  746.   "static int yy_get_next_buffer()",
  747.   "%+",
  748.   "int yyFlexLexer::yy_get_next_buffer()",
  749.   "%*",
  750.   "    {",
  751.   "    register char *dest = yy_current_buffer->yy_ch_buf;",
  752.   "    register char *source = yytext_ptr;",
  753.   "    register int number_to_move, i;",
  754.   "    int ret_val;",
  755.   "",
  756.   "    if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )",
  757.   "        YY_FATAL_ERROR(",
  758.   "        \"fatal flex scanner internal error--end of buffer missed\" );",
  759.   "",
  760.   "    if ( yy_current_buffer->yy_fill_buffer == 0 )",
  761.   "        { /* Don't try to fill the buffer, so this is an EOF. */",
  762.   "        if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )",
  763.   "            {",
  764.   "            /* We matched a single character, the EOB, so",
  765.   "             * treat this as a final EOF.",
  766.   "             */",
  767.   "            return EOB_ACT_END_OF_FILE;",
  768.   "            }",
  769.   "",
  770.   "        else",
  771.   "            {",
  772.   "            /* We matched some text prior to the EOB, first",
  773.   "             * process it.",
  774.   "             */",
  775.   "            return EOB_ACT_LAST_MATCH;",
  776.   "            }",
  777.   "        }",
  778.   "",
  779.   "    /* Try to read more data. */",
  780.   "",
  781.   "    /* First move last chars to start of buffer. */",
  782.   "    number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;",
  783.   "",
  784.   "    for ( i = 0; i < number_to_move; ++i )",
  785.   "        *(dest++) = *(source++);",
  786.   "",
  787.   "    if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )",
  788.   "        /* don't do the read, it's not guaranteed to return an EOF,",
  789.   "         * just force an EOF",
  790.   "         */",
  791.   "        yy_current_buffer->yy_n_chars = yy_n_chars = 0;",
  792.   "",
  793.   "    else",
  794.   "        {",
  795.   "        int num_to_read =",
  796.   "            yy_current_buffer->yy_buf_size - number_to_move - 1;",
  797.   "",
  798.   "        while ( num_to_read <= 0 )",
  799.   "            { /* Not enough room in the buffer - grow it. */",
  800.   "#ifdef YY_USES_REJECT",
  801.   "            YY_FATAL_ERROR(",
  802.   "\"input buffer overflow, can't enlarge buffer because scanner uses REJECT\" );",
  803.   "#else",
  804.   "",
  805.   "            /* just a shorter name for the current buffer */",
  806.   "            YY_BUFFER_STATE b = yy_current_buffer;",
  807.   "",
  808.   "            int yy_c_buf_p_offset =",
  809.   "                (int) (yy_c_buf_p - b->yy_ch_buf);",
  810.   "",
  811.   "            if ( b->yy_is_our_buffer )",
  812.   "                {",
  813.   "                int new_size = b->yy_buf_size * 2;",
  814.   "",
  815.   "                if ( new_size <= 0 )",
  816.   "                    b->yy_buf_size += b->yy_buf_size / 8;",
  817.   "                else",
  818.   "                    b->yy_buf_size *= 2;",
  819.   "",
  820.   "                b->yy_ch_buf = (char *)",
  821.   "                    /* Include room in for 2 EOB chars. */",
  822.   "                    yy_flex_realloc( (void *) b->yy_ch_buf,",
  823.   "                             b->yy_buf_size + 2 );",
  824.   "                }",
  825.   "            else",
  826.   "                /* Can't grow it, we don't own it. */",
  827.   "                b->yy_ch_buf = 0;",
  828.   "",
  829.   "            if ( ! b->yy_ch_buf )",
  830.   "                YY_FATAL_ERROR(",
  831.   "                \"fatal error - scanner input buffer overflow\" );",
  832.   "",
  833.   "            yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];",
  834.   "",
  835.   "            num_to_read = yy_current_buffer->yy_buf_size -",
  836.   "                        number_to_move - 1;",
  837.   "#endif",
  838.   "            }",
  839.   "",
  840.   "        if ( num_to_read > YY_READ_BUF_SIZE )",
  841.   "            num_to_read = YY_READ_BUF_SIZE;",
  842.   "",
  843.   "        /* Read in more data. */",
  844.   "        YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),",
  845.   "            yy_n_chars, num_to_read );",
  846.   "",
  847.   "        yy_current_buffer->yy_n_chars = yy_n_chars;",
  848.   "        }",
  849.   "",
  850.   "    if ( yy_n_chars == 0 )",
  851.   "        {",
  852.   "        if ( number_to_move == YY_MORE_ADJ )",
  853.   "            {",
  854.   "            ret_val = EOB_ACT_END_OF_FILE;",
  855.   "            yyrestart( yyin );",
  856.   "            }",
  857.   "",
  858.   "        else",
  859.   "            {",
  860.   "            ret_val = EOB_ACT_LAST_MATCH;",
  861.   "            yy_current_buffer->yy_buffer_status =",
  862.   "                YY_BUFFER_EOF_PENDING;",
  863.   "            }",
  864.   "        }",
  865.   "",
  866.   "    else",
  867.   "        ret_val = EOB_ACT_CONTINUE_SCAN;",
  868.   "",
  869.   "    yy_n_chars += number_to_move;",
  870.   "    yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;",
  871.   "    yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;",
  872.   "",
  873.   "    yytext_ptr = &yy_current_buffer->yy_ch_buf[0];",
  874.   "",
  875.   "    return ret_val;",
  876.   "    }",
  877.   "",
  878.   "",
  879.   "/* yy_get_previous_state - get the state just before the EOB char was reached */",
  880.   "",
  881.   "%-",
  882.   "static yy_state_type yy_get_previous_state()",
  883.   "%+",
  884.   "yy_state_type yyFlexLexer::yy_get_previous_state()",
  885.   "%*",
  886.   "    {",
  887.   "    register yy_state_type yy_current_state;",
  888.   "    register char *yy_cp;",
  889.   "",
  890.   "%% code to get the start state into yy_current_state goes here",
  891.   "",
  892.   "    for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )",
  893.   "        {",
  894.   "%% code to find the next state goes here",
  895.   "        }",
  896.   "",
  897.   "    return yy_current_state;",
  898.   "    }",
  899.   "",
  900.   "",
  901.   "/* yy_try_NUL_trans - try to make a transition on the NUL character",
  902.   " *",
  903.   " * synopsis",
  904.   " *    next_state = yy_try_NUL_trans( current_state );",
  905.   " */",
  906.   "",
  907.   "%-",
  908.   "#ifdef YY_USE_PROTOS",
  909.   "static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )",
  910.   "#else",
  911.   "static yy_state_type yy_try_NUL_trans( yy_current_state )",
  912.   "yy_state_type yy_current_state;",
  913.   "#endif",
  914.   "%+",
  915.   "yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )",
  916.   "%*",
  917.   "    {",
  918.   "    register int yy_is_jam;",
  919.   "%% code to find the next state, and perhaps do backing up, goes here",
  920.   "",
  921.   "    return yy_is_jam ? 0 : yy_current_state;",
  922.   "    }",
  923.   "",
  924.   "",
  925.   "%-",
  926.   "#ifndef YY_NO_UNPUT",
  927.   "#ifdef YY_USE_PROTOS",
  928.   "static void yyunput( int c, register char *yy_bp )",
  929.   "#else",
  930.   "static void yyunput( c, yy_bp )",
  931.   "int c;",
  932.   "register char *yy_bp;",
  933.   "#endif",
  934.   "%+",
  935.   "void yyFlexLexer::yyunput( int c, register char* yy_bp )",
  936.   "%*",
  937.   "    {",
  938.   "    register char *yy_cp = yy_c_buf_p;",
  939.   "",
  940.   "    /* undo effects of setting up yytext */",
  941.   "    *yy_cp = yy_hold_char;",
  942.   "",
  943.   "    if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )",
  944.   "        { /* need to shift things up to make room */",
  945.   "        /* +2 for EOB chars. */",
  946.   "        register int number_to_move = yy_n_chars + 2;",
  947.   "        register char *dest = &yy_current_buffer->yy_ch_buf[",
  948.   "                    yy_current_buffer->yy_buf_size + 2];",
  949.   "        register char *source =",
  950.   "                &yy_current_buffer->yy_ch_buf[number_to_move];",
  951.   "",
  952.   "        while ( source > yy_current_buffer->yy_ch_buf )",
  953.   "            *--dest = *--source;",
  954.   "",
  955.   "        yy_cp += (int) (dest - source);",
  956.   "        yy_bp += (int) (dest - source);",
  957.   "        yy_current_buffer->yy_n_chars =",
  958.   "            yy_n_chars = yy_current_buffer->yy_buf_size;",
  959.   "",
  960.   "        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )",
  961.   "            YY_FATAL_ERROR( \"flex scanner push-back overflow\" );",
  962.   "        }",
  963.   "",
  964.   "    *--yy_cp = (char) c;",
  965.   "",
  966.   "%% update yylineno here",
  967.   "",
  968.   "    yytext_ptr = yy_bp;",
  969.   "    yy_hold_char = *yy_cp;",
  970.   "    yy_c_buf_p = yy_cp;",
  971.   "    }",
  972.   "%-",
  973.   "#endif    /* ifndef YY_NO_UNPUT */",
  974.   "%*",
  975.   "",
  976.   "",
  977.   "%-",
  978.   "#ifdef __cplusplus",
  979.   "static int yyinput()",
  980.   "#else",
  981.   "static int input()",
  982.   "#endif",
  983.   "%+",
  984.   "int yyFlexLexer::yyinput()",
  985.   "%*",
  986.   "    {",
  987.   "    int c;",
  988.   "",
  989.   "    *yy_c_buf_p = yy_hold_char;",
  990.   "",
  991.   "    if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )",
  992.   "        {",
  993.   "        /* yy_c_buf_p now points to the character we want to return.",
  994.   "         * If this occurs *before* the EOB characters, then it's a",
  995.   "         * valid NUL; if not, then we've hit the end of the buffer.",
  996.   "         */",
  997.   "        if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )",
  998.   "            /* This was really a NUL. */",
  999.   "            *yy_c_buf_p = '\\0';",
  1000.   "",
  1001.   "        else",
  1002.   "            { /* need more input */",
  1003.   "            int offset = yy_c_buf_p - yytext_ptr;",
  1004.   "            ++yy_c_buf_p;",
  1005.   "",
  1006.   "            switch ( yy_get_next_buffer() )",
  1007.   "                {",
  1008.   "                case EOB_ACT_LAST_MATCH:",
  1009.   "                    /* This happens because yy_g_n_b()",
  1010.   "                     * sees that we've accumulated a",
  1011.   "                     * token and flags that we need to",
  1012.   "                     * try matching the token before",
  1013.   "                     * proceeding.  But for input(),",
  1014.   "                     * there's no matching to consider.",
  1015.   "                     * So convert the EOB_ACT_LAST_MATCH",
  1016.   "                     * to EOB_ACT_END_OF_FILE.",
  1017.   "                     */",
  1018.   "",
  1019.   "                    /* Reset buffer status. */",
  1020.   "                    yyrestart( yyin );",
  1021.   "",
  1022.   "                    /* fall through */",
  1023.   "",
  1024.   "                case EOB_ACT_END_OF_FILE:",
  1025.   "                    {",
  1026.   "                    if ( yywrap() )",
  1027.   "                        return EOF;",
  1028.   "",
  1029.   "                    if ( ! yy_did_buffer_switch_on_eof )",
  1030.   "                        YY_NEW_FILE;",
  1031.   "#ifdef __cplusplus",
  1032.   "                    return yyinput();",
  1033.   "#else",
  1034.   "                    return input();",
  1035.   "#endif",
  1036.   "                    }",
  1037.   "",
  1038.   "                case EOB_ACT_CONTINUE_SCAN:",
  1039.   "                    yy_c_buf_p = yytext_ptr + offset;",
  1040.   "                    break;",
  1041.   "                }",
  1042.   "            }",
  1043.   "        }",
  1044.   "",
  1045.   "    c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */",
  1046.   "    *yy_c_buf_p = '\\0';    /* preserve yytext */",
  1047.   "    yy_hold_char = *++yy_c_buf_p;",
  1048.   "",
  1049.   "%% update BOL and yylineno",
  1050.   "",
  1051.   "    return c;",
  1052.   "    }",
  1053.   "",
  1054.   "",
  1055.   "%-",
  1056.   "#ifdef YY_USE_PROTOS",
  1057.   "void yyrestart( FILE *input_file )",
  1058.   "#else",
  1059.   "void yyrestart( input_file )",
  1060.   "FILE *input_file;",
  1061.   "#endif",
  1062.   "%+",
  1063.   "void yyFlexLexer::yyrestart( istream* input_file )",
  1064.   "%*",
  1065.   "    {",
  1066.   "    if ( ! yy_current_buffer )",
  1067.   "        yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );",
  1068.   "",
  1069.   "    yy_init_buffer( yy_current_buffer, input_file );",
  1070.   "    yy_load_buffer_state();",
  1071.   "    }",
  1072.   "",
  1073.   "",
  1074.   "%-",
  1075.   "#ifdef YY_USE_PROTOS",
  1076.   "void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
  1077.   "#else",
  1078.   "void yy_switch_to_buffer( new_buffer )",
  1079.   "YY_BUFFER_STATE new_buffer;",
  1080.   "#endif",
  1081.   "%+",
  1082.   "void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )",
  1083.   "%*",
  1084.   "    {",
  1085.   "    if ( yy_current_buffer == new_buffer )",
  1086.   "        return;",
  1087.   "",
  1088.   "    if ( yy_current_buffer )",
  1089.   "        {",
  1090.   "        /* Flush out information for old buffer. */",
  1091.   "        *yy_c_buf_p = yy_hold_char;",
  1092.   "        yy_current_buffer->yy_buf_pos = yy_c_buf_p;",
  1093.   "        yy_current_buffer->yy_n_chars = yy_n_chars;",
  1094.   "        }",
  1095.   "",
  1096.   "    yy_current_buffer = new_buffer;",
  1097.   "    yy_load_buffer_state();",
  1098.   "",
  1099.   "    /* We don't actually know whether we did this switch during",
  1100.   "     * EOF (yywrap()) processing, but the only time this flag",
  1101.   "     * is looked at is after yywrap() is called, so it's safe",
  1102.   "     * to go ahead and always set it.",
  1103.   "     */",
  1104.   "    yy_did_buffer_switch_on_eof = 1;",
  1105.   "    }",
  1106.   "",
  1107.   "",
  1108.   "%-",
  1109.   "#ifdef YY_USE_PROTOS",
  1110.   "void yy_load_buffer_state( void )",
  1111.   "#else",
  1112.   "void yy_load_buffer_state()",
  1113.   "#endif",
  1114.   "%+",
  1115.   "void yyFlexLexer::yy_load_buffer_state()",
  1116.   "%*",
  1117.   "    {",
  1118.   "    yy_n_chars = yy_current_buffer->yy_n_chars;",
  1119.   "    yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;",
  1120.   "    yyin = yy_current_buffer->yy_input_file;",
  1121.   "    yy_hold_char = *yy_c_buf_p;",
  1122.   "    }",
  1123.   "",
  1124.   "",
  1125.   "%-",
  1126.   "#ifdef YY_USE_PROTOS",
  1127.   "YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )",
  1128.   "#else",
  1129.   "YY_BUFFER_STATE yy_create_buffer( file, size )",
  1130.   "FILE *file;",
  1131.   "int size;",
  1132.   "#endif",
  1133.   "%+",
  1134.   "YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )",
  1135.   "%*",
  1136.   "    {",
  1137.   "    YY_BUFFER_STATE b;",
  1138.   "",
  1139.   "    b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );",
  1140.   "    if ( ! b )",
  1141.   "        YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );",
  1142.   "",
  1143.   "    b->yy_buf_size = size;",
  1144.   "",
  1145.   "    /* yy_ch_buf has to be 2 characters longer than the size given because",
  1146.   "     * we need to put in 2 end-of-buffer characters.",
  1147.   "     */",
  1148.   "    b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );",
  1149.   "    if ( ! b->yy_ch_buf )",
  1150.   "        YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );",
  1151.   "",
  1152.   "    b->yy_is_our_buffer = 1;",
  1153.   "",
  1154.   "    yy_init_buffer( b, file );",
  1155.   "",
  1156.   "    return b;",
  1157.   "    }",
  1158.   "",
  1159.   "",
  1160.   "%-",
  1161.   "#ifdef YY_USE_PROTOS",
  1162.   "void yy_delete_buffer( YY_BUFFER_STATE b )",
  1163.   "#else",
  1164.   "void yy_delete_buffer( b )",
  1165.   "YY_BUFFER_STATE b;",
  1166.   "#endif",
  1167.   "%+",
  1168.   "void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )",
  1169.   "%*",
  1170.   "    {",
  1171.   "    if ( ! b )",
  1172.   "        return;",
  1173.   "",
  1174.   "    if ( b == yy_current_buffer )",
  1175.   "        yy_current_buffer = (YY_BUFFER_STATE) 0;",
  1176.   "",
  1177.   "    if ( b->yy_is_our_buffer )",
  1178.   "        yy_flex_free( (void *) b->yy_ch_buf );",
  1179.   "",
  1180.   "    yy_flex_free( (void *) b );",
  1181.   "    }",
  1182.   "",
  1183.   "",
  1184.   "%-",
  1185.   "#ifndef YY_ALWAYS_INTERACTIVE",
  1186.   "#ifndef YY_NEVER_INTERACTIVE",
  1187.   "extern int isatty YY_PROTO(( int ));",
  1188.   "#endif",
  1189.   "#endif",
  1190.   "",
  1191.   "#ifdef YY_USE_PROTOS",
  1192.   "void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )",
  1193.   "#else",
  1194.   "void yy_init_buffer( b, file )",
  1195.   "YY_BUFFER_STATE b;",
  1196.   "FILE *file;",
  1197.   "#endif",
  1198.   "",
  1199.   "%+",
  1200.   "extern \"C\" int isatty YY_PROTO(( int ));",
  1201.   "void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )",
  1202.   "%*",
  1203.   "",
  1204.   "    {",
  1205.   "    yy_flush_buffer( b );",
  1206.   "",
  1207.   "    b->yy_input_file = file;",
  1208.   "    b->yy_fill_buffer = 1;",
  1209.   "",
  1210.   "%-",
  1211.   "#if YY_ALWAYS_INTERACTIVE",
  1212.   "    b->yy_is_interactive = 1;",
  1213.   "#else",
  1214.   "#if YY_NEVER_INTERACTIVE",
  1215.   "    b->yy_is_interactive = 0;",
  1216.   "#else",
  1217.   "    b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;",
  1218.   "#endif",
  1219.   "#endif",
  1220.   "%+",
  1221.   "    b->yy_is_interactive = 0;",
  1222.   "%*",
  1223.   "    }",
  1224.   "",
  1225.   "",
  1226.   "%-",
  1227.   "#ifdef YY_USE_PROTOS",
  1228.   "void yy_flush_buffer( YY_BUFFER_STATE b )",
  1229.   "#else",
  1230.   "void yy_flush_buffer( b )",
  1231.   "YY_BUFFER_STATE b;",
  1232.   "#endif",
  1233.   "",
  1234.   "%+",
  1235.   "void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )",
  1236.   "%*",
  1237.   "    {",
  1238.   "    if ( ! b )",
  1239.   "        return;",
  1240.   "",
  1241.   "    b->yy_n_chars = 0;",
  1242.   "",
  1243.   "    /* We always need two end-of-buffer characters.  The first causes",
  1244.   "     * a transition to the end-of-buffer state.  The second causes",
  1245.   "     * a jam in that state.",
  1246.   "     */",
  1247.   "    b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;",
  1248.   "    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;",
  1249.   "",
  1250.   "    b->yy_buf_pos = &b->yy_ch_buf[0];",
  1251.   "",
  1252.   "    b->yy_at_bol = 1;",
  1253.   "    b->yy_buffer_status = YY_BUFFER_NEW;",
  1254.   "",
  1255.   "    if ( b == yy_current_buffer )",
  1256.   "        yy_load_buffer_state();",
  1257.   "    }",
  1258.   "%*",
  1259.   "",
  1260.   "",
  1261.   "#ifndef YY_NO_SCAN_BUFFER",
  1262.   "%-",
  1263.   "#ifdef YY_USE_PROTOS",
  1264.   "YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )",
  1265.   "#else",
  1266.   "YY_BUFFER_STATE yy_scan_buffer( base, size )",
  1267.   "char *base;",
  1268.   "yy_size_t size;",
  1269.   "#endif",
  1270.   "    {",
  1271.   "    YY_BUFFER_STATE b;",
  1272.   "",
  1273.   "    if ( size < 2 ||",
  1274.   "         base[size-2] != YY_END_OF_BUFFER_CHAR ||",
  1275.   "         base[size-1] != YY_END_OF_BUFFER_CHAR )",
  1276.   "        /* They forgot to leave room for the EOB's. */",
  1277.   "        return 0;",
  1278.   "",
  1279.   "    b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );",
  1280.   "    if ( ! b )",
  1281.   "        YY_FATAL_ERROR( \"out of dynamic memory in yy_scan_buffer()\" );",
  1282.   "",
  1283.   "    b->yy_buf_size = size - 2;    /* \"- 2\" to take care of EOB's */",
  1284.   "    b->yy_buf_pos = b->yy_ch_buf = base;",
  1285.   "    b->yy_is_our_buffer = 0;",
  1286.   "    b->yy_input_file = 0;",
  1287.   "    b->yy_n_chars = b->yy_buf_size;",
  1288.   "    b->yy_is_interactive = 0;",
  1289.   "    b->yy_at_bol = 1;",
  1290.   "    b->yy_fill_buffer = 0;",
  1291.   "    b->yy_buffer_status = YY_BUFFER_NEW;",
  1292.   "",
  1293.   "    yy_switch_to_buffer( b );",
  1294.   "",
  1295.   "    return b;",
  1296.   "    }",
  1297.   "%*",
  1298.   "#endif",
  1299.   "",
  1300.   "",
  1301.   "#ifndef YY_NO_SCAN_STRING",
  1302.   "%-",
  1303.   "#ifdef YY_USE_PROTOS",
  1304.   "YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )",
  1305.   "#else",
  1306.   "YY_BUFFER_STATE yy_scan_string( yy_str )",
  1307.   "yyconst char *yy_str;",
  1308.   "#endif",
  1309.   "    {",
  1310.   "    int len;",
  1311.   "    for ( len = 0; yy_str[len]; ++len )",
  1312.   "        ;",
  1313.   "",
  1314.   "    return yy_scan_bytes( yy_str, len );",
  1315.   "    }",
  1316.   "%*",
  1317.   "#endif",
  1318.   "",
  1319.   "",
  1320.   "#ifndef YY_NO_SCAN_BYTES",
  1321.   "%-",
  1322.   "#ifdef YY_USE_PROTOS",
  1323.   "YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )",
  1324.   "#else",
  1325.   "YY_BUFFER_STATE yy_scan_bytes( bytes, len )",
  1326.   "yyconst char *bytes;",
  1327.   "int len;",
  1328.   "#endif",
  1329.   "    {",
  1330.   "    YY_BUFFER_STATE b;",
  1331.   "    char *buf;",
  1332.   "    yy_size_t n;",
  1333.   "    int i;",
  1334.   "",
  1335.   "    /* Get memory for full buffer, including space for trailing EOB's. */",
  1336.   "    n = len + 2;",
  1337.   "    buf = (char *) yy_flex_alloc( n );",
  1338.   "    if ( ! buf )",
  1339.   "        YY_FATAL_ERROR( \"out of dynamic memory in yy_scan_bytes()\" );",
  1340.   "",
  1341.   "    for ( i = 0; i < len; ++i )",
  1342.   "        buf[i] = bytes[i];",
  1343.   "",
  1344.   "    buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;",
  1345.   "",
  1346.   "    b = yy_scan_buffer( buf, n );",
  1347.   "    if ( ! b )",
  1348.   "        YY_FATAL_ERROR( \"bad buffer in yy_scan_bytes()\" );",
  1349.   "",
  1350.   "    /* It's okay to grow etc. this buffer, and we should throw it",
  1351.   "     * away when we're done.",
  1352.   "     */",
  1353.   "    b->yy_is_our_buffer = 1;",
  1354.   "",
  1355.   "    return b;",
  1356.   "    }",
  1357.   "%*",
  1358.   "#endif",
  1359.   "",
  1360.   "",
  1361.   "#ifndef YY_NO_PUSH_STATE",
  1362.   "%-",
  1363.   "#ifdef YY_USE_PROTOS",
  1364.   "static void yy_push_state( int new_state )",
  1365.   "#else",
  1366.   "static void yy_push_state( new_state )",
  1367.   "int new_state;",
  1368.   "#endif",
  1369.   "%+",
  1370.   "void yyFlexLexer::yy_push_state( int new_state )",
  1371.   "%*",
  1372.   "    {",
  1373.   "    if ( yy_start_stack_ptr >= yy_start_stack_depth )",
  1374.   "        {",
  1375.   "        yy_size_t new_size;",
  1376.   "",
  1377.   "        yy_start_stack_depth += YY_START_STACK_INCR;",
  1378.   "        new_size = yy_start_stack_depth * sizeof( int );",
  1379.   "",
  1380.   "        if ( ! yy_start_stack )",
  1381.   "            yy_start_stack = (int *) yy_flex_alloc( new_size );",
  1382.   "",
  1383.   "        else",
  1384.   "            yy_start_stack = (int *) yy_flex_realloc(",
  1385.   "                    (void *) yy_start_stack, new_size );",
  1386.   "",
  1387.   "        if ( ! yy_start_stack )",
  1388.   "            YY_FATAL_ERROR(",
  1389.   "            \"out of memory expanding start-condition stack\" );",
  1390.   "        }",
  1391.   "",
  1392.   "    yy_start_stack[yy_start_stack_ptr++] = YY_START;",
  1393.   "",
  1394.   "    BEGIN(new_state);",
  1395.   "    }",
  1396.   "#endif",
  1397.   "",
  1398.   "",
  1399.   "#ifndef YY_NO_POP_STATE",
  1400.   "%-",
  1401.   "static void yy_pop_state()",
  1402.   "%+",
  1403.   "void yyFlexLexer::yy_pop_state()",
  1404.   "%*",
  1405.   "    {",
  1406.   "    if ( --yy_start_stack_ptr < 0 )",
  1407.   "        YY_FATAL_ERROR( \"start-condition stack underflow\" );",
  1408.   "",
  1409.   "    BEGIN(yy_start_stack[yy_start_stack_ptr]);",
  1410.   "    }",
  1411.   "#endif",
  1412.   "",
  1413.   "",
  1414.   "#ifndef YY_NO_TOP_STATE",
  1415.   "%-",
  1416.   "static int yy_top_state()",
  1417.   "%+",
  1418.   "int yyFlexLexer::yy_top_state()",
  1419.   "%*",
  1420.   "    {",
  1421.   "    return yy_start_stack[yy_start_stack_ptr - 1];",
  1422.   "    }",
  1423.   "#endif",
  1424.   "",
  1425.   "#ifndef YY_EXIT_FAILURE",
  1426.   "#define YY_EXIT_FAILURE 2",
  1427.   "#endif",
  1428.   "",
  1429.   "%-",
  1430.   "#ifdef YY_USE_PROTOS",
  1431.   "static void yy_fatal_error( yyconst char msg[] )",
  1432.   "#else",
  1433.   "static void yy_fatal_error( msg )",
  1434.   "char msg[];",
  1435.   "#endif",
  1436.   "    {",
  1437.   "    (void) fprintf( stderr, \"%s\\n\", msg );",
  1438.   "    exit( YY_EXIT_FAILURE );",
  1439.   "    }",
  1440.   "",
  1441.   "%+",
  1442.   "",
  1443.   "void yyFlexLexer::LexerError( yyconst char msg[] )",
  1444.   "    {",
  1445.   "    cerr << msg << '\\n';",
  1446.   "    exit( YY_EXIT_FAILURE );",
  1447.   "    }",
  1448.   "%*",
  1449.   "",
  1450.   "",
  1451.   "/* Redefine yyless() so it works in section 3 code. */",
  1452.   "",
  1453.   "#undef yyless",
  1454.   "#define yyless(n) \\",
  1455.   "    do \\",
  1456.   "        { \\",
  1457.   "        /* Undo effects of setting up yytext. */ \\",
  1458.   "        yytext[yyleng] = yy_hold_char; \\",
  1459.   "        yy_c_buf_p = yytext + n; \\",
  1460.   "        yy_hold_char = *yy_c_buf_p; \\",
  1461.   "        *yy_c_buf_p = '\\0'; \\",
  1462.   "        yyleng = n; \\",
  1463.   "        } \\",
  1464.   "    while ( 0 )",
  1465.   "",
  1466.   "",
  1467.   "/* Internal utility routines. */",
  1468.   "",
  1469.   "#ifndef yytext_ptr",
  1470.   "#ifdef YY_USE_PROTOS",
  1471.   "static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )",
  1472.   "#else",
  1473.   "static void yy_flex_strncpy( s1, s2, n )",
  1474.   "char *s1;",
  1475.   "yyconst char *s2;",
  1476.   "int n;",
  1477.   "#endif",
  1478.   "    {",
  1479.   "    register int i;",
  1480.   "    for ( i = 0; i < n; ++i )",
  1481.   "        s1[i] = s2[i];",
  1482.   "    }",
  1483.   "#endif",
  1484.   "",
  1485.   "#ifdef YY_NEED_STRLEN",
  1486.   "#ifdef YY_USE_PROTOS",
  1487.   "static int yy_flex_strlen( yyconst char *s )",
  1488.   "#else",
  1489.   "static int yy_flex_strlen( s )",
  1490.   "yyconst char *s;",
  1491.   "#endif",
  1492.   "    {",
  1493.   "    register int n;",
  1494.   "    for ( n = 0; s[n]; ++n )",
  1495.   "        ;",
  1496.   "",
  1497.   "    return n;",
  1498.   "    }",
  1499.   "#endif",
  1500.   "",
  1501.   "",
  1502.   "#ifdef YY_USE_PROTOS",
  1503.   "static void *yy_flex_alloc( yy_size_t size )",
  1504.   "#else",
  1505.   "static void *yy_flex_alloc( size )",
  1506.   "yy_size_t size;",
  1507.   "#endif",
  1508.   "    {",
  1509.   "    return (void *) malloc( size );",
  1510.   "    }",
  1511.   "",
  1512.   "#ifdef YY_USE_PROTOS",
  1513.   "static void *yy_flex_realloc( void *ptr, yy_size_t size )",
  1514.   "#else",
  1515.   "static void *yy_flex_realloc( ptr, size )",
  1516.   "void *ptr;",
  1517.   "yy_size_t size;",
  1518.   "#endif",
  1519.   "    {",
  1520.   "    /* The cast to (char *) in the following accommodates both",
  1521.   "     * implementations that use char* generic pointers, and those",
  1522.   "     * that use void* generic pointers.  It works with the latter",
  1523.   "     * because both ANSI C and C++ allow castless assignment from",
  1524.   "     * any pointer type to void*, and deal with argument conversions",
  1525.   "     * as though doing an assignment.",
  1526.   "     */",
  1527.   "    return (void *) realloc( (char *) ptr, size );",
  1528.   "    }",
  1529.   "",
  1530.   "#ifdef YY_USE_PROTOS",
  1531.   "static void yy_flex_free( void *ptr )",
  1532.   "#else",
  1533.   "static void yy_flex_free( ptr )",
  1534.   "void *ptr;",
  1535.   "#endif",
  1536.   "    {",
  1537.   "    free( ptr );",
  1538.   "    }",
  1539.   "",
  1540.   "#if YY_MAIN",
  1541.   "int main()",
  1542.   "    {",
  1543.   "    yylex();",
  1544.   "    return 0;",
  1545.   "    }",
  1546.   "#endif",
  1547.   0
  1548. };
  1549.